Successfully roundtrip the lockfile

This writes out and reads the lockfile, but it does nothing to verify
that the lockfile is still up to date, so it's not actually ready to be
used.

diff --git a/src/cargo/core/resolver.rs b/src/cargo/core/resolver.rs
index 5b4e8118407417506656a65e3a42f60add40624c..a405cfa2550bf5320fb558c2d824a489a6ca1f08 100644 (file)
--- a/src/cargo/core/resolver.rs
+++ b/src/cargo/core/resolver.rs
@@ -36,7 +36,8 @@ impl EncodableResolve {
             add_pkg_to_graph(&mut g, dep, default);
         }
 
-        Ok(Resolve { graph: g, root: try!(self.root.to_package_id(default)) })
+        let root = self.root.to_package_id(default);
+        Ok(Resolve { graph: g, root: try!(root) })
     }
 }
 

diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs
index 367de1d15134d9d2f96f73c7dc4b47bc4d987438..f22e13d8730ce7567670019cf4e972622f0e829c 100644 (file)
--- a/src/cargo/ops/cargo_compile.rs
+++ b/src/cargo/ops/cargo_compile.rs
@@ -24,13 +24,15 @@
 
 use std::os;
 use std::collections::HashMap;
+use std::io::File;
+use serialize::Decodable;
 
 use core::registry::PackageRegistry;
-use core::{MultiShell, Source, SourceId, PackageSet, Target, PackageId, resolver};
+use core::{MultiShell, Source, SourceId, PackageSet, Target, PackageId, Resolve, resolver};
 use ops;
 use sources::{PathSource};
 use util::config::{Config, ConfigValue};
-use util::{CargoResult, Wrap, config, internal, human, ChainError};
+use util::{CargoResult, Wrap, config, internal, human, ChainError, toml};
 
 pub struct CompileOptions<'a> {
     pub update: bool,
@@ -65,14 +67,22 @@ pub fn compile(manifest_path: &Path,
     let source_ids = package.get_source_ids();
 
     let (packages, resolve, sources) = {
+        let lockfile = manifest_path.dir_path().join("Cargo.lock");
+        let source_id = package.get_package_id().get_source_id();
+
         let mut config = try!(Config::new(*shell, update, jobs, target.clone()));
 
         let mut registry =
             try!(PackageRegistry::new(source_ids, override_ids, &mut config));
 
-        let resolved = try!(resolver::resolve(package.get_package_id(),
-                                              package.get_dependencies(),
-                                              &mut registry));
+        let resolved = match try!(load_lockfile(&lockfile, source_id)) {
+            Some(r) => r,
+            None => {
+                try!(resolver::resolve(package.get_package_id(),
+                                       package.get_dependencies(),
+                                       &mut registry))
+            }
+        };
 
         let req: Vec<PackageId> = resolved.iter().map(|r| r.clone()).collect();
         let packages = try!(registry.get(req.as_slice()).wrap({
@@ -116,6 +126,20 @@ pub fn compile(manifest_path: &Path,
     Ok(test_executables)
 }
 
+fn load_lockfile(path: &Path, sid: &SourceId) -> CargoResult<Option<Resolve>> {
+    // If there is no lockfile, return none.
+    let mut f = match File::open(path) {
+        Ok(f) => f,
+        Err(_) => return Ok(None)
+    };
+
+    let s = try!(f.read_to_string());
+
+    let mut d = ::toml::Decoder::new(::toml::Table(try!(toml::parse(s.as_slice(), path))));
+    let v: resolver::EncodableResolve = Decodable::decode(&mut d).unwrap();
+    Ok(Some(try!(v.to_resolve(sid))))
+}
+
 fn source_ids_from_config(configs: &HashMap<String, config::ConfigValue>,
                           cur_path: Path) -> CargoResult<Vec<SourceId>> {
     debug!("loaded config; configs={}", configs);

diff --git a/src/cargo/ops/cargo_generate_lockfile.rs b/src/cargo/ops/cargo_generate_lockfile.rs
index 9bea6159debf20fae72afb65f56fbc00b5c71c07..b49f1e9c7e3a4bcb4e6ab3aad3700d86772f8d30 100644 (file)
--- a/src/cargo/ops/cargo_generate_lockfile.rs
+++ b/src/cargo/ops/cargo_generate_lockfile.rs
@@ -52,8 +52,6 @@ fn write_resolve(resolve: Resolve) {
 
     let root = e.toml.find(&"root".to_string()).unwrap();
 
-    println!("root={}", root);
-
     out.push_str("[root]\n");
     emit_package(root.as_table().unwrap(), &mut out);
 
@@ -72,7 +70,6 @@ fn write_resolve(resolve: Resolve) {
     let mut d = Decoder::new(toml::Table(e.toml.clone()));
     let v: resolver::EncodableResolve = Decodable::decode(&mut d).unwrap();
 
-    println!("{}", v);
 }
 
 fn emit_package(dep: &TreeMap<String, toml::Value>, out: &mut String) {

diff --git a/src/cargo/util/config.rs b/src/cargo/util/config.rs
index 9b43be817d379e4b88288aacca579a40aa6d41db..4ed519ab1aa1d36e70949068246fd39efe233330 100644 (file)
--- a/src/cargo/util/config.rs
+++ b/src/cargo/util/config.rs
@@ -244,9 +244,7 @@ pub fn all_configs(pwd: Path) -> CargoResult<HashMap<String, ConfigValue>> {
     try!(walk_tree(&pwd, |mut file| {
         let path = file.path().clone();
         let contents = try!(file.read_to_string());
-        let file = path.filename_display().to_string();
-        let table = try!(cargo_toml::parse(contents.as_slice(),
-                                           file.as_slice()).chain_error(|| {
+        let table = try!(cargo_toml::parse(contents.as_slice(), &path).chain_error(|| {
             internal(format!("could not parse Toml manifest; path={}",
                              path.display()))
         }));
@@ -308,9 +306,7 @@ fn walk_tree(pwd: &Path,
 
 fn extract_config(mut file: io::fs::File, key: &str) -> CargoResult<ConfigValue> {
     let contents = try!(file.read_to_string());
-    let mut toml = try!(cargo_toml::parse(contents.as_slice(),
-                                          file.path().filename_display()
-                                              .to_string().as_slice()));
+    let mut toml = try!(cargo_toml::parse(contents.as_slice(), file.path()));
     let val = try!(toml.pop(&key.to_string()).require(|| internal("")));
 
     ConfigValue::from_toml(file.path(), val)

diff --git a/src/cargo/util/toml.rs b/src/cargo/util/toml.rs
index ad55d640ab1e18b86717e01887f6291037d566cf..f8f9cecf042e7ad4990b9172766798b4725add71 100644 (file)
--- a/src/cargo/util/toml.rs
+++ b/src/cargo/util/toml.rs
@@ -87,7 +87,7 @@ pub fn to_manifest(contents: &[u8],
     let contents = try!(str::from_utf8(contents).require(|| {
         human("Cargo.toml is not valid UTF-8")
     }));
-    let root = try!(parse(contents, "Cargo.toml"));
+    let root = try!(parse(contents, &Path::new("Cargo.toml")));
     let mut d = toml::Decoder::new(toml::Table(root));
     let toml_manifest: TomlManifest = match Decodable::decode(&mut d) {
         Ok(t) => t,
@@ -130,7 +130,7 @@ pub fn to_manifest(contents: &[u8],
     }
 }
 
-pub fn parse(toml: &str, file: &str) -> CargoResult<toml::Table> {
+pub fn parse(toml: &str, file: &Path) -> CargoResult<toml::Table> {
     let mut parser = toml::Parser::new(toml.as_slice());
     match parser.parse() {
         Some(toml) => return Ok(toml),
@@ -141,7 +141,7 @@ pub fn parse(toml: &str, file: &str) -> CargoResult<toml::Table> {
         let (loline, locol) = parser.to_linecol(error.lo);
         let (hiline, hicol) = parser.to_linecol(error.hi);
         error_str.push_str(format!("{}:{}:{}{} {}\n",
-                                   file,
+                                   file.filename_display(),
                                    loline + 1, locol + 1,
                                    if loline != hiline || locol != hicol {
                                        format!("-{}:{}", hiline + 1,